home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / cert.h < prev    next >
C/C++ Source or Header  |  2006-04-20  |  49KB  |  1,529 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Netscape security libraries.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the MPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the MPL, the GPL or the LGPL.
  34.  *
  35.  * ***** END LICENSE BLOCK ***** */
  36.  
  37. /*
  38.  * cert.h - public data structures and prototypes for the certificate library
  39.  *
  40.  * $Id: cert.h,v 1.53 2005/03/09 23:02:47 neil.williams%sun.com Exp $
  41.  */
  42.  
  43. #ifndef _CERT_H_
  44. #define _CERT_H_
  45.  
  46. #include "plarena.h"
  47. #include "plhash.h"
  48. #include "prlong.h"
  49. #include "prlog.h"
  50.  
  51. #include "seccomon.h"
  52. #include "secdert.h"
  53. #include "secoidt.h"
  54. #include "keyt.h"
  55. #include "certt.h"
  56.  
  57. SEC_BEGIN_PROTOS
  58.    
  59. /****************************************************************************
  60.  *
  61.  * RFC1485 ascii to/from X.? RelativeDistinguishedName (aka CERTName)
  62.  *
  63.  ****************************************************************************/
  64.  
  65. /*
  66. ** Convert an ascii RFC1485 encoded name into its CERTName equivalent.
  67. */
  68. extern CERTName *CERT_AsciiToName(char *string);
  69.  
  70. /*
  71. ** Convert an CERTName into its RFC1485 encoded equivalent.
  72. ** Returns a string that must be freed with PORT_Free().
  73. */
  74. extern char *CERT_NameToAscii(CERTName *name);
  75.  
  76. extern CERTAVA *CERT_CopyAVA(PRArenaPool *arena, CERTAVA *src);
  77.  
  78. /* convert an OID to dotted-decimal representation */
  79. /* Returns a string that must be freed with PR_smprintf_free(). */
  80. extern char * CERT_GetOidString(const SECItem *oid);
  81.  
  82. /*
  83. ** Examine an AVA and return the tag that refers to it. The AVA tags are
  84. ** defined as SEC_OID_AVA*.
  85. */
  86. extern SECOidTag CERT_GetAVATag(CERTAVA *ava);
  87.  
  88. /*
  89. ** Compare two AVA's, returning the difference between them.
  90. */
  91. extern SECComparison CERT_CompareAVA(const CERTAVA *a, const CERTAVA *b);
  92.  
  93. /*
  94. ** Create an RDN (relative-distinguished-name). The argument list is a
  95. ** NULL terminated list of AVA's.
  96. */
  97. extern CERTRDN *CERT_CreateRDN(PRArenaPool *arena, CERTAVA *avas, ...);
  98.  
  99. /*
  100. ** Make a copy of "src" storing it in "dest".
  101. */
  102. extern SECStatus CERT_CopyRDN(PRArenaPool *arena, CERTRDN *dest, CERTRDN *src);
  103.  
  104. /*
  105. ** Destory an RDN object.
  106. **    "rdn" the RDN to destroy
  107. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  108. */
  109. extern void CERT_DestroyRDN(CERTRDN *rdn, PRBool freeit);
  110.  
  111. /*
  112. ** Add an AVA to an RDN.
  113. **    "rdn" the RDN to add to
  114. **    "ava" the AVA to add
  115. */
  116. extern SECStatus CERT_AddAVA(PRArenaPool *arena, CERTRDN *rdn, CERTAVA *ava);
  117.  
  118. /*
  119. ** Compare two RDN's, returning the difference between them.
  120. */
  121. extern SECComparison CERT_CompareRDN(CERTRDN *a, CERTRDN *b);
  122.  
  123. /*
  124. ** Create an X.500 style name using a NULL terminated list of RDN's.
  125. */
  126. extern CERTName *CERT_CreateName(CERTRDN *rdn, ...);
  127.  
  128. /*
  129. ** Make a copy of "src" storing it in "dest". Memory is allocated in
  130. ** "dest" for each of the appropriate sub objects. Memory is not freed in
  131. ** "dest" before allocation is done (use CERT_DestroyName(dest, PR_FALSE) to
  132. ** do that).
  133. */
  134. extern SECStatus CERT_CopyName(PRArenaPool *arena, CERTName *dest, CERTName *src);
  135.  
  136. /*
  137. ** Destroy a Name object.
  138. **    "name" the CERTName to destroy
  139. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  140. */
  141. extern void CERT_DestroyName(CERTName *name);
  142.  
  143. /*
  144. ** Add an RDN to a name.
  145. **    "name" the name to add the RDN to
  146. **    "rdn" the RDN to add to name
  147. */
  148. extern SECStatus CERT_AddRDN(CERTName *name, CERTRDN *rdn);
  149.  
  150. /*
  151. ** Compare two names, returning the difference between them.
  152. */
  153. extern SECComparison CERT_CompareName(CERTName *a, CERTName *b);
  154.  
  155. /*
  156. ** Convert a CERTName into something readable
  157. */
  158. extern char *CERT_FormatName (CERTName *name);
  159.  
  160. /*
  161. ** Convert a der-encoded integer to a hex printable string form.
  162. ** Perhaps this should be a SEC function but it's only used for certs.
  163. */
  164. extern char *CERT_Hexify (SECItem *i, int do_colon);
  165.  
  166. /******************************************************************************
  167.  *
  168.  * Certificate handling operations
  169.  *
  170.  *****************************************************************************/
  171.  
  172. /*
  173. ** Create a new validity object given two unix time values.
  174. **    "notBefore" the time before which the validity is not valid
  175. **    "notAfter" the time after which the validity is not valid
  176. */
  177. extern CERTValidity *CERT_CreateValidity(int64 notBefore, int64 notAfter);
  178.  
  179. /*
  180. ** Destroy a validity object.
  181. **    "v" the validity to destroy
  182. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  183. */
  184. extern void CERT_DestroyValidity(CERTValidity *v);
  185.  
  186. /*
  187. ** Copy the "src" object to "dest". Memory is allocated in "dest" for
  188. ** each of the appropriate sub-objects. Memory in "dest" is not freed
  189. ** before memory is allocated (use CERT_DestroyValidity(v, PR_FALSE) to do
  190. ** that).
  191. */
  192. extern SECStatus CERT_CopyValidity
  193.    (PRArenaPool *arena, CERTValidity *dest, CERTValidity *src);
  194.  
  195. /*
  196. ** The cert lib considers a cert or CRL valid if the "notBefore" time is
  197. ** in the not-too-distant future, e.g. within the next 24 hours. This 
  198. ** prevents freshly issued certificates from being considered invalid
  199. ** because the local system's time zone is incorrectly set.  
  200. ** The amount of "pending slop time" is adjustable by the application.
  201. ** Units of SlopTime are seconds.  Default is 86400  (24 hours).
  202. ** Negative SlopTime values are not allowed.
  203. */
  204. PRInt32 CERT_GetSlopTime(void);
  205.  
  206. SECStatus CERT_SetSlopTime(PRInt32 slop);
  207.  
  208. /*
  209. ** Create a new certificate object. The result must be wrapped with an
  210. ** CERTSignedData to create a signed certificate.
  211. **    "serialNumber" the serial number
  212. **    "issuer" the name of the certificate issuer
  213. **    "validity" the validity period of the certificate
  214. **    "req" the certificate request that prompted the certificate issuance
  215. */
  216. extern CERTCertificate *
  217. CERT_CreateCertificate (unsigned long serialNumber, CERTName *issuer,
  218.             CERTValidity *validity, CERTCertificateRequest *req);
  219.  
  220. /*
  221. ** Destroy a certificate object
  222. **    "cert" the certificate to destroy
  223. ** NOTE: certificate's are reference counted. This call decrements the
  224. ** reference count, and if the result is zero, then the object is destroyed
  225. ** and optionally freed.
  226. */
  227. extern void CERT_DestroyCertificate(CERTCertificate *cert);
  228.  
  229. /*
  230. ** Make a shallow copy of a certificate "c". Just increments the
  231. ** reference count on "c".
  232. */
  233. extern CERTCertificate *CERT_DupCertificate(CERTCertificate *c);
  234.  
  235. /*
  236. ** Create a new certificate request. This result must be wrapped with an
  237. ** CERTSignedData to create a signed certificate request.
  238. **    "name" the subject name (who the certificate request is from)
  239. **    "spki" describes/defines the public key the certificate is for
  240. **    "attributes" if non-zero, some optional attribute data
  241. */
  242. extern CERTCertificateRequest *
  243. CERT_CreateCertificateRequest (CERTName *name, CERTSubjectPublicKeyInfo *spki,
  244.                    SECItem **attributes);
  245.  
  246. /*
  247. ** Destroy a certificate-request object
  248. **    "r" the certificate-request to destroy
  249. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  250. */
  251. extern void CERT_DestroyCertificateRequest(CERTCertificateRequest *r);
  252.  
  253. /*
  254. ** Start adding extensions to a certificate request.
  255. */
  256. void *
  257. CERT_StartCertificateRequestAttributes(CERTCertificateRequest *req);
  258.  
  259. /*
  260. ** Reformat the certifcate extension list into a CertificateRequest
  261. ** attribute list.
  262. */
  263. SECStatus
  264. CERT_FinishCertificateRequestAttributes(CERTCertificateRequest *req);
  265.  
  266. /*
  267. ** Extract the Extension Requests from a DER CertRequest attribute list.
  268. */
  269. SECStatus
  270. CERT_GetCertificateRequestExtensions(CERTCertificateRequest *req,
  271.                                      CERTCertExtension ***exts);
  272.  
  273. /*
  274. ** Extract a public key object from a certificate
  275. */
  276. extern SECKEYPublicKey *CERT_ExtractPublicKey(CERTCertificate *cert);
  277.  
  278. /*
  279.  * used to get a public key with Key Material ID. Only used for fortezza V1
  280.  * certificates.
  281.  */
  282. extern SECKEYPublicKey *CERT_KMIDPublicKey(CERTCertificate *cert);
  283.  
  284.  
  285. /*
  286. ** Retrieve the Key Type associated with the cert we're dealing with
  287. */
  288.  
  289. extern KeyType CERT_GetCertKeyType (CERTSubjectPublicKeyInfo *spki);
  290.  
  291. /*
  292. ** Initialize the certificate database.  This is called to create
  293. **  the initial list of certificates in the database.
  294. */
  295. extern SECStatus CERT_InitCertDB(CERTCertDBHandle *handle);
  296.  
  297. extern int CERT_GetDBContentVersion(CERTCertDBHandle *handle);
  298.  
  299. /*
  300. ** Default certificate database routines
  301. */
  302. extern void CERT_SetDefaultCertDB(CERTCertDBHandle *handle);
  303.  
  304. extern CERTCertDBHandle *CERT_GetDefaultCertDB(void);
  305.  
  306. extern CERTCertList *CERT_GetCertChainFromCert(CERTCertificate *cert, 
  307.                            int64 time, 
  308.                            SECCertUsage usage);
  309. extern CERTCertificate *
  310. CERT_NewTempCertificate (CERTCertDBHandle *handle, SECItem *derCert,
  311.                          char *nickname, PRBool isperm, PRBool copyDER);
  312.  
  313.  
  314. /******************************************************************************
  315.  *
  316.  * X.500 Name handling operations
  317.  *
  318.  *****************************************************************************/
  319.  
  320. /*
  321. ** Create an AVA (attribute-value-assertion)
  322. **    "arena" the memory arena to alloc from
  323. **    "kind" is one of SEC_OID_AVA_*
  324. **    "valueType" is one of DER_PRINTABLE_STRING, DER_IA5_STRING, or
  325. **       DER_T61_STRING
  326. **    "value" is the null terminated string containing the value
  327. */
  328. extern CERTAVA *CERT_CreateAVA
  329.    (PRArenaPool *arena, SECOidTag kind, int valueType, char *value);
  330.  
  331. /*
  332. ** Extract the Distinguished Name from a DER encoded certificate
  333. **    "derCert" is the DER encoded certificate
  334. **    "derName" is the SECItem that the name is returned in
  335. */
  336. extern SECStatus CERT_NameFromDERCert(SECItem *derCert, SECItem *derName);
  337.  
  338. /*
  339. ** Extract the Issuers Distinguished Name from a DER encoded certificate
  340. **    "derCert" is the DER encoded certificate
  341. **    "derName" is the SECItem that the name is returned in
  342. */
  343. extern SECStatus CERT_IssuerNameFromDERCert(SECItem *derCert, 
  344.                         SECItem *derName);
  345.  
  346. extern SECItem *
  347. CERT_EncodeGeneralName(CERTGeneralName *genName, SECItem *dest,
  348.                PRArenaPool *arena);
  349.  
  350. extern CERTGeneralName *
  351. CERT_DecodeGeneralName(PRArenaPool *arena, SECItem *encodedName,
  352.                CERTGeneralName  *genName);
  353.  
  354.  
  355.  
  356. /*
  357. ** Generate a database search key for a certificate, based on the
  358. ** issuer and serial number.
  359. **    "arena" the memory arena to alloc from
  360. **    "derCert" the DER encoded certificate
  361. **    "key" the returned key
  362. */
  363. extern SECStatus CERT_KeyFromDERCert(PRArenaPool *arena, SECItem *derCert, SECItem *key);
  364.  
  365. extern SECStatus CERT_KeyFromIssuerAndSN(PRArenaPool *arena, SECItem *issuer,
  366.                      SECItem *sn, SECItem *key);
  367.  
  368. extern SECStatus CERT_SerialNumberFromDERCert(SECItem *derCert, 
  369.                         SECItem *derName);
  370.  
  371.  
  372. /*
  373. ** Generate a database search key for a crl, based on the
  374. ** issuer.
  375. **    "arena" the memory arena to alloc from
  376. **    "derCrl" the DER encoded crl
  377. **    "key" the returned key
  378. */
  379. extern SECStatus CERT_KeyFromDERCrl(PRArenaPool *arena, SECItem *derCrl, SECItem *key);
  380.  
  381. /*
  382. ** Open the certificate database.  Use callback to get name of database.
  383. */
  384. extern SECStatus CERT_OpenCertDB(CERTCertDBHandle *handle, PRBool readOnly,
  385.                  CERTDBNameFunc namecb, void *cbarg);
  386.  
  387. /* Open the certificate database.  Use given filename for database. */
  388. extern SECStatus CERT_OpenCertDBFilename(CERTCertDBHandle *handle,
  389.                      char *certdbname, PRBool readOnly);
  390.  
  391. /*
  392. ** Open and initialize a cert database that is entirely in memory.  This
  393. ** can be used when the permanent database can not be opened or created.
  394. */
  395. extern SECStatus CERT_OpenVolatileCertDB(CERTCertDBHandle *handle);
  396.  
  397. /*
  398. ** Check the hostname to make sure that it matches the shexp that
  399. ** is given in the common name of the certificate.
  400. */
  401. extern SECStatus CERT_VerifyCertName(CERTCertificate *cert, const char *hostname);
  402.  
  403. /*
  404. ** Add a domain name to the list of names that the user has explicitly
  405. ** allowed (despite cert name mismatches) for use with a server cert.
  406. */
  407. extern SECStatus CERT_AddOKDomainName(CERTCertificate *cert, const char *hostname);
  408.  
  409. /*
  410. ** Decode a DER encoded certificate into an CERTCertificate structure
  411. **    "derSignedCert" is the DER encoded signed certificate
  412. **    "copyDER" is true if the DER should be copied, false if the
  413. **        existing copy should be referenced
  414. **    "nickname" is the nickname to use in the database.  If it is NULL
  415. **        then a temporary nickname is generated.
  416. */
  417. extern CERTCertificate *
  418. CERT_DecodeDERCertificate (SECItem *derSignedCert, PRBool copyDER, char *nickname);
  419. /*
  420. ** Decode a DER encoded CRL/KRL into an CERTSignedCrl structure
  421. **    "derSignedCrl" is the DER encoded signed crl/krl.
  422. **    "type" is this a CRL or KRL.
  423. */
  424. #define SEC_CRL_TYPE    1
  425. #define SEC_KRL_TYPE    0
  426.  
  427. extern CERTSignedCrl *
  428. CERT_DecodeDERCrl (PRArenaPool *arena, SECItem *derSignedCrl,int type);
  429.  
  430. /*
  431.  * same as CERT_DecodeDERCrl, plus allow options to be passed in
  432.  */
  433.  
  434. extern CERTSignedCrl *
  435. CERT_DecodeDERCrlWithFlags(PRArenaPool *narena, SECItem *derSignedCrl,
  436.                           int type, PRInt32 options);
  437.  
  438. /* CRL options to pass */
  439.  
  440. #define CRL_DECODE_DEFAULT_OPTIONS          0x00000000
  441.  
  442. /* when CRL_DECODE_DONT_COPY_DER is set, the DER is not copied . The
  443.    application must then keep derSignedCrl until it destroys the
  444.    CRL . Ideally, it should allocate derSignedCrl in an arena
  445.    and pass that arena in as the first argument to
  446.    CERT_DecodeDERCrlWithFlags */
  447.  
  448. #define CRL_DECODE_DONT_COPY_DER            0x00000001
  449. #define CRL_DECODE_SKIP_ENTRIES             0x00000002
  450. #define CRL_DECODE_KEEP_BAD_CRL             0x00000004
  451. #define CRL_DECODE_ADOPT_HEAP_DER           0x00000008
  452.  
  453. /* complete the decoding of a partially decoded CRL, ie. decode the
  454.    entries. Note that entries is an optional field in a CRL, so the
  455.    "entries" pointer in CERTCrlStr may still be NULL even after
  456.    function returns SECSuccess */
  457.  
  458. extern SECStatus CERT_CompleteCRLDecodeEntries(CERTSignedCrl* crl);
  459.  
  460. /* Validate CRL then import it to the dbase.  If there is already a CRL with the
  461.  * same CA in the dbase, it will be replaced if derCRL is more up to date.  
  462.  * If the process successes, a CRL will be returned.  Otherwise, a NULL will 
  463.  * be returned. The caller should call PORT_GetError() for the exactly error 
  464.  * code.
  465.  */
  466. extern CERTSignedCrl *
  467. CERT_ImportCRL (CERTCertDBHandle *handle, SECItem *derCRL, char *url, 
  468.                         int type, void * wincx);
  469.  
  470. extern void CERT_DestroyCrl (CERTSignedCrl *crl);
  471.  
  472. /* this is a hint to flush the CRL cache. crlKey is the DER subject of
  473.    the issuer (CA). */
  474. void CERT_CRLCacheRefreshIssuer(CERTCertDBHandle* dbhandle, SECItem* crlKey);
  475.  
  476. /* add the specified DER CRL object to the CRL cache. Doing so will allow
  477.    certificate verification functions (such as CERT_VerifyCertificate)
  478.    to automatically find and make use of this CRL object.
  479.    Once a CRL is added to the CRL cache, the application must hold on to
  480.    the object's memory, because the cache will reference it directly. The
  481.    application can only free the object after it calls CERT_UncacheCRL to
  482.    remove it from the CRL cache.
  483. */
  484. SECStatus CERT_CacheCRL(CERTCertDBHandle* dbhandle, SECItem* newcrl);
  485.  
  486. /* remove a previously added CRL object from the CRL cache. It is OK
  487.    for the application to free the memory after a successful removal
  488. */
  489. SECStatus CERT_UncacheCRL(CERTCertDBHandle* dbhandle, SECItem* oldcrl);
  490.  
  491. /*
  492. ** Decode a certificate and put it into the temporary certificate database
  493. */
  494. extern CERTCertificate *
  495. CERT_DecodeCertificate (SECItem *derCert, char *nickname,PRBool copyDER);
  496.  
  497. /*
  498. ** Find a certificate in the database
  499. **    "key" is the database key to look for
  500. */
  501. extern CERTCertificate *CERT_FindCertByKey(CERTCertDBHandle *handle, SECItem *key);
  502.  
  503. /*
  504. ** Find a certificate in the database by name
  505. **    "name" is the distinguished name to look up
  506. */
  507. extern CERTCertificate *
  508. CERT_FindCertByName (CERTCertDBHandle *handle, SECItem *name);
  509.  
  510. /*
  511. ** Find a certificate in the database by name
  512. **    "name" is the distinguished name to look up (in ascii)
  513. */
  514. extern CERTCertificate *
  515. CERT_FindCertByNameString (CERTCertDBHandle *handle, char *name);
  516.  
  517. /*
  518. ** Find a certificate in the database by name and keyid
  519. **    "name" is the distinguished name to look up
  520. **    "keyID" is the value of the subjectKeyID to match
  521. */
  522. extern CERTCertificate *
  523. CERT_FindCertByKeyID (CERTCertDBHandle *handle, SECItem *name, SECItem *keyID);
  524.  
  525. /*
  526. ** Generate a certificate key from the issuer and serialnumber, then look it
  527. ** up in the database.  Return the cert if found.
  528. **    "issuerAndSN" is the issuer and serial number to look for
  529. */
  530. extern CERTCertificate *
  531. CERT_FindCertByIssuerAndSN (CERTCertDBHandle *handle, CERTIssuerAndSN *issuerAndSN);
  532.  
  533. /*
  534. ** Find a certificate in the database by a subject key ID
  535. **    "subjKeyID" is the subject Key ID to look for
  536. */
  537. extern CERTCertificate *
  538. CERT_FindCertBySubjectKeyID (CERTCertDBHandle *handle, SECItem *subjKeyID);
  539.  
  540. /*
  541. ** Find a certificate in the database by a nickname
  542. **    "nickname" is the ascii string nickname to look for
  543. */
  544. extern CERTCertificate *
  545. CERT_FindCertByNickname (CERTCertDBHandle *handle, char *nickname);
  546.  
  547. /*
  548. ** Find a certificate in the database by a DER encoded certificate
  549. **    "derCert" is the DER encoded certificate
  550. */
  551. extern CERTCertificate *
  552. CERT_FindCertByDERCert(CERTCertDBHandle *handle, SECItem *derCert);
  553.  
  554. /*
  555. ** Find a certificate in the database by a email address
  556. **    "emailAddr" is the email address to look up
  557. */
  558. CERTCertificate *
  559. CERT_FindCertByEmailAddr(CERTCertDBHandle *handle, char *emailAddr);
  560.  
  561. /*
  562. ** Find a certificate in the database by a email address or nickname
  563. **    "name" is the email address or nickname to look up
  564. */
  565. CERTCertificate *
  566. CERT_FindCertByNicknameOrEmailAddr(CERTCertDBHandle *handle, char *name);
  567.  
  568. /*
  569. ** Find a certificate in the database by a digest of a subject public key
  570. **    "spkDigest" is the digest to look up
  571. */
  572. extern CERTCertificate *
  573. CERT_FindCertBySPKDigest(CERTCertDBHandle *handle, SECItem *spkDigest);
  574.  
  575. /*
  576.  * Find the issuer of a cert
  577.  */
  578. CERTCertificate *
  579. CERT_FindCertIssuer(CERTCertificate *cert, int64 validTime, SECCertUsage usage);
  580.  
  581. /*
  582. ** Check the validity times of a certificate vs. time 't', allowing
  583. ** some slop for broken clocks and stuff.
  584. **    "cert" is the certificate to be checked
  585. **    "t" is the time to check against
  586. **    "allowOverride" if true then check to see if the invalidity has
  587. **        been overridden by the user.
  588. */
  589. extern SECCertTimeValidity CERT_CheckCertValidTimes(CERTCertificate *cert,
  590.                             PRTime t,
  591.                             PRBool allowOverride);
  592.  
  593. /*
  594. ** WARNING - this function is depricated, and will either go away or have
  595. **        a new API in the near future.
  596. **
  597. ** Check the validity times of a certificate vs. the current time, allowing
  598. ** some slop for broken clocks and stuff.
  599. **    "cert" is the certificate to be checked
  600. */
  601. extern SECStatus CERT_CertTimesValid(CERTCertificate *cert);
  602.  
  603. /*
  604. ** Extract the validity times from a certificate
  605. **    "c" is the certificate
  606. **    "notBefore" is the start of the validity period
  607. **    "notAfter" is the end of the validity period
  608. */
  609. extern SECStatus
  610. CERT_GetCertTimes (CERTCertificate *c, PRTime *notBefore, PRTime *notAfter);
  611.  
  612. /*
  613. ** Extract the issuer and serial number from a certificate
  614. */
  615. extern CERTIssuerAndSN *CERT_GetCertIssuerAndSN(PRArenaPool *, 
  616.                             CERTCertificate *);
  617.  
  618. /*
  619. ** verify the signature of a signed data object with a given certificate
  620. **    "sd" the signed data object to be verified
  621. **    "cert" the certificate to use to check the signature
  622. */
  623. extern SECStatus CERT_VerifySignedData(CERTSignedData *sd,
  624.                        CERTCertificate *cert,
  625.                        int64 t,
  626.                        void *wincx);
  627. /*
  628. ** verify the signature of a signed data object with the given DER publickey
  629. */
  630. extern SECStatus
  631. CERT_VerifySignedDataWithPublicKeyInfo(CERTSignedData *sd,
  632.                                        CERTSubjectPublicKeyInfo *pubKeyInfo,
  633.                                        void *wincx);
  634.  
  635. /*
  636. ** verify the signature of a signed data object with a SECKEYPublicKey.
  637. */
  638. extern SECStatus
  639. CERT_VerifySignedDataWithPublicKey(CERTSignedData *sd,
  640.                                    SECKEYPublicKey *pubKey, void *wincx);
  641.  
  642. /*
  643. ** NEW FUNCTIONS with new bit-field-FIELD SECCertificateUsage - please use
  644. ** verify a certificate by checking validity times against a certain time,
  645. ** that we trust the issuer, and that the signature on the certificate is
  646. ** valid.
  647. **    "cert" the certificate to verify
  648. **    "checkSig" only check signatures if true
  649. */
  650. extern SECStatus
  651. CERT_VerifyCertificate(CERTCertDBHandle *handle, CERTCertificate *cert,
  652.         PRBool checkSig, SECCertificateUsage requiredUsages,
  653.                 int64 t, void *wincx, CERTVerifyLog *log,
  654.                 SECCertificateUsage* returnedUsages);
  655.  
  656. /* same as above, but uses current time */
  657. extern SECStatus
  658. CERT_VerifyCertificateNow(CERTCertDBHandle *handle, CERTCertificate *cert,
  659.            PRBool checkSig, SECCertificateUsage requiredUsages,
  660.                    void *wincx, SECCertificateUsage* returnedUsages);
  661.  
  662. /*
  663. ** Verify that a CA cert can certify some (unspecified) leaf cert for a given
  664. ** purpose. This is used by UI code to help identify where a chain may be
  665. ** broken and why. This takes identical parameters to CERT_VerifyCert
  666. */
  667. extern SECStatus
  668. CERT_VerifyCACertForUsage(CERTCertDBHandle *handle, CERTCertificate *cert,
  669.         PRBool checkSig, SECCertUsage certUsage, int64 t,
  670.         void *wincx, CERTVerifyLog *log);
  671.  
  672. /*
  673. ** OLD OBSOLETE FUNCTIONS with enum SECCertUsage - DO NOT USE FOR NEW CODE
  674. ** verify a certificate by checking validity times against a certain time,
  675. ** that we trust the issuer, and that the signature on the certificate is
  676. ** valid.
  677. **    "cert" the certificate to verify
  678. **    "checkSig" only check signatures if true
  679. */
  680. extern SECStatus
  681. CERT_VerifyCert(CERTCertDBHandle *handle, CERTCertificate *cert,
  682.         PRBool checkSig, SECCertUsage certUsage, int64 t,
  683.         void *wincx, CERTVerifyLog *log);
  684.  
  685. /* same as above, but uses current time */
  686. extern SECStatus
  687. CERT_VerifyCertNow(CERTCertDBHandle *handle, CERTCertificate *cert,
  688.            PRBool checkSig, SECCertUsage certUsage, void *wincx);
  689.  
  690. SECStatus
  691. CERT_VerifyCertChain(CERTCertDBHandle *handle, CERTCertificate *cert,
  692.              PRBool checkSig, SECCertUsage certUsage, int64 t,
  693.              void *wincx, CERTVerifyLog *log);
  694.  
  695. /*
  696. ** Read a base64 ascii encoded DER certificate and convert it to our
  697. ** internal format.
  698. **    "certstr" is a null-terminated string containing the certificate
  699. */
  700. extern CERTCertificate *CERT_ConvertAndDecodeCertificate(char *certstr);
  701.  
  702. /*
  703. ** Read a certificate in some foreign format, and convert it to our
  704. ** internal format.
  705. **    "certbuf" is the buffer containing the certificate
  706. **    "certlen" is the length of the buffer
  707. ** NOTE - currently supports netscape base64 ascii encoded raw certs
  708. **  and netscape binary DER typed files.
  709. */
  710. extern CERTCertificate *CERT_DecodeCertFromPackage(char *certbuf, int certlen);
  711.  
  712. extern SECStatus
  713. CERT_ImportCAChain (SECItem *certs, int numcerts, SECCertUsage certUsage);
  714.  
  715. extern SECStatus
  716. CERT_ImportCAChainTrusted(SECItem *certs, int numcerts, SECCertUsage certUsage);
  717.  
  718. /*
  719. ** Read a certificate chain in some foreign format, and pass it to a 
  720. ** callback function.
  721. **    "certbuf" is the buffer containing the certificate
  722. **    "certlen" is the length of the buffer
  723. **    "f" is the callback function
  724. **    "arg" is the callback argument
  725. */
  726. typedef SECStatus (PR_CALLBACK *CERTImportCertificateFunc)
  727.    (void *arg, SECItem **certs, int numcerts);
  728.  
  729. extern SECStatus
  730. CERT_DecodeCertPackage(char *certbuf, int certlen, CERTImportCertificateFunc f,
  731.                void *arg);
  732.  
  733. /*
  734. ** Pretty print a certificate in HTML
  735. **    "cert" is the certificate to print
  736. **    "showImages" controls whether or not to use about:security URLs
  737. **        for subject and issuer images.  This should only be true
  738. **        in the browser.
  739. */
  740. extern char *CERT_HTMLCertInfo(CERTCertificate *cert, PRBool showImages,
  741.                    PRBool showIssuer);
  742.  
  743. /* 
  744. ** Returns the value of an AVA.  This was a formerly static 
  745. ** function that has been exposed due to the need to decode
  746. ** and convert unicode strings to UTF8.  
  747. **
  748. ** XXX This function resides in certhtml.c, should it be
  749. ** moved elsewhere?
  750. */
  751. extern SECItem *CERT_DecodeAVAValue(const SECItem *derAVAValue);
  752.  
  753.  
  754.  
  755. /*
  756. ** extract various element strings from a distinguished name.
  757. **    "name" the distinguished name
  758. */
  759.  
  760. extern char *CERT_GetCertificateEmailAddress(CERTCertificate *cert);
  761.  
  762. extern char *CERT_GetCertEmailAddress(CERTName *name);
  763.  
  764. extern const char * CERT_GetFirstEmailAddress(CERTCertificate * cert);
  765.  
  766. extern const char * CERT_GetNextEmailAddress(CERTCertificate * cert, 
  767.                                              const char * prev);
  768.  
  769. /* The return value must be freed with PORT_Free. */
  770. extern char *CERT_GetCommonName(CERTName *name);
  771.  
  772. extern char *CERT_GetCountryName(CERTName *name);
  773.  
  774. extern char *CERT_GetLocalityName(CERTName *name);
  775.  
  776. extern char *CERT_GetStateName(CERTName *name);
  777.  
  778. extern char *CERT_GetOrgName(CERTName *name);
  779.  
  780. extern char *CERT_GetOrgUnitName(CERTName *name);
  781.  
  782. extern char *CERT_GetDomainComponentName(CERTName *name);
  783.  
  784. extern char *CERT_GetCertUid(CERTName *name);
  785.  
  786. /* manipulate the trust parameters of a certificate */
  787.  
  788. extern SECStatus CERT_GetCertTrust(CERTCertificate *cert, CERTCertTrust *trust);
  789.  
  790. extern SECStatus
  791. CERT_ChangeCertTrust (CERTCertDBHandle *handle, CERTCertificate *cert,
  792.               CERTCertTrust *trust);
  793.  
  794. extern SECStatus
  795. CERT_ChangeCertTrustByUsage(CERTCertDBHandle *certdb, CERTCertificate *cert,
  796.                 SECCertUsage usage);
  797.  
  798. /*************************************************************************
  799.  *
  800.  * manipulate the extensions of a certificate
  801.  *
  802.  ************************************************************************/
  803.  
  804. /*
  805. ** Set up a cert for adding X509v3 extensions.  Returns an opaque handle
  806. ** used by the next two routines.
  807. **    "cert" is the certificate we are adding extensions to
  808. */
  809. extern void *CERT_StartCertExtensions(CERTCertificate *cert);
  810.  
  811. /*
  812. ** Add an extension to a certificate.
  813. **    "exthandle" is the handle returned by the previous function
  814. **    "idtag" is the integer tag for the OID that should ID this extension
  815. **    "value" is the value of the extension
  816. **    "critical" is the critical extension flag
  817. **    "copyData" is a flag indicating whether the value data should be
  818. **        copied.
  819. */
  820. extern SECStatus CERT_AddExtension (void *exthandle, int idtag, 
  821.             SECItem *value, PRBool critical, PRBool copyData);
  822.  
  823. extern SECStatus CERT_AddExtensionByOID (void *exthandle, SECItem *oid,
  824.              SECItem *value, PRBool critical, PRBool copyData);
  825.  
  826. extern SECStatus CERT_EncodeAndAddExtension
  827.    (void *exthandle, int idtag, void *value, PRBool critical,
  828.     const SEC_ASN1Template *atemplate);
  829.  
  830. extern SECStatus CERT_EncodeAndAddBitStrExtension
  831.    (void *exthandle, int idtag, SECItem *value, PRBool critical);
  832.  
  833.  
  834. extern SECStatus
  835. CERT_EncodeAltNameExtension(PRArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue);
  836.  
  837.  
  838. /*
  839. ** Finish adding cert extensions.  Does final processing on extension
  840. ** data, putting it in the right format, and freeing any temporary
  841. ** storage.
  842. **    "exthandle" is the handle used to add extensions to a certificate
  843. */
  844. extern SECStatus CERT_FinishExtensions(void *exthandle);
  845.  
  846. /*
  847. ** Merge an external list of extensions into a cert's extension list, adding one
  848. ** only when its OID matches none of the cert's existing extensions. Call this
  849. ** immediately before calling CERT_FinishExtensions().
  850. */
  851. SECStatus
  852. CERT_MergeExtensions(void *exthandle, CERTCertExtension **exts);
  853.  
  854. /* If the extension is found, return its criticality and value.
  855. ** This allocate storage for the returning extension value.
  856. */
  857. extern SECStatus CERT_GetExtenCriticality
  858.    (CERTCertExtension **extensions, int tag, PRBool *isCritical);
  859.  
  860. extern void
  861. CERT_DestroyOidSequence(CERTOidSequence *oidSeq);
  862.  
  863. /****************************************************************************
  864.  *
  865.  * DER encode and decode extension values
  866.  *
  867.  ****************************************************************************/
  868.  
  869. /* Encode the value of the basicConstraint extension.
  870. **    arena - where to allocate memory for the encoded value.
  871. **    value - extension value to encode
  872. **    encodedValue - output encoded value
  873. */
  874. extern SECStatus CERT_EncodeBasicConstraintValue
  875.    (PRArenaPool *arena, CERTBasicConstraints *value, SECItem *encodedValue);
  876.  
  877. /*
  878. ** Encode the value of the authorityKeyIdentifier extension.
  879. */
  880. extern SECStatus CERT_EncodeAuthKeyID
  881.    (PRArenaPool *arena, CERTAuthKeyID *value, SECItem *encodedValue);
  882.  
  883. /*
  884. ** Encode the value of the crlDistributionPoints extension.
  885. */
  886. extern SECStatus CERT_EncodeCRLDistributionPoints
  887.    (PRArenaPool *arena, CERTCrlDistributionPoints *value,SECItem *derValue);
  888.  
  889. /*
  890. ** Decodes a DER encoded basicConstaint extension value into a readable format
  891. **    value - decoded value
  892. **    encodedValue - value to decoded
  893. */
  894. extern SECStatus CERT_DecodeBasicConstraintValue
  895.    (CERTBasicConstraints *value, SECItem *encodedValue);
  896.  
  897. /* Decodes a DER encoded authorityKeyIdentifier extension value into a
  898. ** readable format.
  899. **    arena - where to allocate memory for the decoded value
  900. **    encodedValue - value to be decoded
  901. **    Returns a CERTAuthKeyID structure which contains the decoded value
  902. */
  903. extern CERTAuthKeyID *CERT_DecodeAuthKeyID 
  904.             (PRArenaPool *arena, SECItem *encodedValue);
  905.  
  906.  
  907. /* Decodes a DER encoded crlDistributionPoints extension value into a 
  908. ** readable format.
  909. **    arena - where to allocate memory for the decoded value
  910. **    der - value to be decoded
  911. **    Returns a CERTCrlDistributionPoints structure which contains the 
  912. **          decoded value
  913. */
  914. extern CERTCrlDistributionPoints * CERT_DecodeCRLDistributionPoints
  915.    (PRArenaPool *arena, SECItem *der);
  916.  
  917. /* Extract certain name type from a generalName */
  918. extern void *CERT_GetGeneralNameByType
  919.    (CERTGeneralName *genNames, CERTGeneralNameType type, PRBool derFormat);
  920.  
  921.  
  922. extern CERTOidSequence *
  923. CERT_DecodeOidSequence(SECItem *seqItem);
  924.  
  925.  
  926.  
  927.  
  928. /****************************************************************************
  929.  *
  930.  * Find extension values of a certificate 
  931.  *
  932.  ***************************************************************************/
  933.  
  934. extern SECStatus CERT_FindCertExtension
  935.    (CERTCertificate *cert, int tag, SECItem *value);
  936.  
  937. extern SECStatus CERT_FindNSCertTypeExtension
  938.    (CERTCertificate *cert, SECItem *value);
  939.  
  940. extern char * CERT_FindNSStringExtension (CERTCertificate *cert, int oidtag);
  941.  
  942. extern SECStatus CERT_FindIssuerCertExtension
  943.    (CERTCertificate *cert, int tag, SECItem *value);
  944.  
  945. extern SECStatus CERT_FindCertExtensionByOID
  946.    (CERTCertificate *cert, SECItem *oid, SECItem *value);
  947.  
  948. extern char *CERT_FindCertURLExtension (CERTCertificate *cert, int tag, 
  949.                                 int catag);
  950.  
  951. /* Returns the decoded value of the authKeyID extension.
  952. **   Note that this uses passed in the arena to allocate storage for the result
  953. */
  954. extern CERTAuthKeyID * CERT_FindAuthKeyIDExten (PRArenaPool *arena,CERTCertificate *cert);
  955.  
  956. /* Returns the decoded value of the basicConstraint extension.
  957.  */
  958. extern SECStatus CERT_FindBasicConstraintExten
  959.    (CERTCertificate *cert, CERTBasicConstraints *value);
  960.  
  961. /* Returns the decoded value of the crlDistributionPoints extension.
  962. **  Note that the arena in cert is used to allocate storage for the result
  963. */
  964. extern CERTCrlDistributionPoints * CERT_FindCRLDistributionPoints
  965.    (CERTCertificate *cert);
  966.  
  967. /* Returns value of the keyUsage extension.  This uses PR_Alloc to allocate 
  968. ** buffer for the decoded value. The caller should free up the storage 
  969. ** allocated in value->data.
  970. */
  971. extern SECStatus CERT_FindKeyUsageExtension (CERTCertificate *cert, 
  972.                             SECItem *value);
  973.  
  974. /* Return the decoded value of the subjectKeyID extension. The caller should 
  975. ** free up the storage allocated in retItem->data.
  976. */
  977. extern SECStatus CERT_FindSubjectKeyIDExtension (CERTCertificate *cert, 
  978.                                SECItem *retItem);
  979.  
  980. /*
  981. ** If cert is a v3 certificate, and a critical keyUsage extension is included,
  982. ** then check the usage against the extension value.  If a non-critical 
  983. ** keyUsage extension is included, this will return SECSuccess without 
  984. ** checking, since the extension is an advisory field, not a restriction.  
  985. ** If cert is not a v3 certificate, this will return SECSuccess.
  986. **    cert - certificate
  987. **    usage - one of the x.509 v3 the Key Usage Extension flags
  988. */
  989. extern SECStatus CERT_CheckCertUsage (CERTCertificate *cert, 
  990.                             unsigned char usage);
  991.  
  992. /****************************************************************************
  993.  *
  994.  *  CRL v2 Extensions supported routines
  995.  *
  996.  ****************************************************************************/
  997.  
  998. extern SECStatus CERT_FindCRLExtensionByOID
  999.    (CERTCrl *crl, SECItem *oid, SECItem *value);
  1000.  
  1001. extern SECStatus CERT_FindCRLExtension
  1002.    (CERTCrl *crl, int tag, SECItem *value);
  1003.  
  1004. extern SECStatus
  1005.    CERT_FindInvalidDateExten (CERTCrl *crl, int64 *value);
  1006.  
  1007. /*
  1008. ** Set up a crl for adding X509v3 extensions.  Returns an opaque handle
  1009. ** used by routines that take an exthandle (void*) argument .
  1010. **    "crl" is the CRL we are adding extensions to
  1011. */
  1012. extern void *CERT_StartCRLExtensions(CERTCrl *crl);
  1013.  
  1014. /*
  1015. ** Set up a crl entry for adding X509v3 extensions.  Returns an opaque handle
  1016. ** used by routines that take an exthandle (void*) argument .
  1017. **    "crl" is the crl we are adding certs entries to
  1018. **      "entry" is the crl entry we are adding extensions to
  1019. */
  1020. extern void *CERT_StartCRLEntryExtensions(CERTCrl *crl, CERTCrlEntry *entry);
  1021.  
  1022. extern CERTCertNicknames *CERT_GetCertNicknames (CERTCertDBHandle *handle,
  1023.                          int what, void *wincx);
  1024.  
  1025. /*
  1026. ** Finds the crlNumber extension and decodes its value into 'value'
  1027. */
  1028. extern SECStatus CERT_FindCRLNumberExten (CERTCrl *crl, CERTCrlNumber *value);
  1029.  
  1030. extern void CERT_FreeNicknames(CERTCertNicknames *nicknames);
  1031.  
  1032. extern PRBool CERT_CompareCerts(CERTCertificate *c1, CERTCertificate *c2);
  1033.  
  1034. extern PRBool CERT_CompareCertsForRedirection(CERTCertificate *c1,
  1035.                              CERTCertificate *c2);
  1036.  
  1037. /*
  1038. ** Generate an array of the Distinguished Names that the given cert database
  1039. ** "trusts"
  1040. */
  1041. extern CERTDistNames *CERT_GetSSLCACerts(CERTCertDBHandle *handle);
  1042.  
  1043. extern void CERT_FreeDistNames(CERTDistNames *names);
  1044.  
  1045. /*
  1046. ** Generate an array of Distinguished names from an array of nicknames
  1047. */
  1048. extern CERTDistNames *CERT_DistNamesFromNicknames
  1049.    (CERTCertDBHandle *handle, char **nicknames, int nnames);
  1050.  
  1051. /*
  1052. ** Generate a certificate chain from a certificate.
  1053. */
  1054. extern CERTCertificateList *
  1055. CERT_CertChainFromCert(CERTCertificate *cert, SECCertUsage usage,
  1056.                PRBool includeRoot);
  1057.  
  1058. extern CERTCertificateList *
  1059. CERT_CertListFromCert(CERTCertificate *cert);
  1060.  
  1061. extern CERTCertificateList *
  1062. CERT_DupCertList(CERTCertificateList * oldList);
  1063.  
  1064. extern void CERT_DestroyCertificateList(CERTCertificateList *list);
  1065.  
  1066. /*
  1067. ** is cert a user cert? i.e. does it have CERTDB_USER trust,
  1068. ** i.e. a private key?
  1069. */
  1070. PRBool CERT_IsUserCert(CERTCertificate* cert);
  1071.  
  1072. /* is cert a newer than cert b? */
  1073. PRBool CERT_IsNewer(CERTCertificate *certa, CERTCertificate *certb);
  1074.  
  1075. /* currently a stub for address book */
  1076. PRBool
  1077. CERT_IsCertRevoked(CERTCertificate *cert);
  1078.  
  1079. void
  1080. CERT_DestroyCertArray(CERTCertificate **certs, unsigned int ncerts);
  1081.  
  1082. /* convert an email address to lower case */
  1083. char *CERT_FixupEmailAddr(char *emailAddr);
  1084.  
  1085. /* decode string representation of trust flags into trust struct */
  1086. SECStatus
  1087. CERT_DecodeTrustString(CERTCertTrust *trust, char *trusts);
  1088.  
  1089. /* encode trust struct into string representation of trust flags */
  1090. char *
  1091. CERT_EncodeTrustString(CERTCertTrust *trust);
  1092.  
  1093. /* find the next or prev cert in a subject list */
  1094. CERTCertificate *
  1095. CERT_PrevSubjectCert(CERTCertificate *cert);
  1096. CERTCertificate *
  1097. CERT_NextSubjectCert(CERTCertificate *cert);
  1098.  
  1099. /*
  1100.  * import a collection of certs into the temporary or permanent cert
  1101.  * database
  1102.  */
  1103. SECStatus
  1104. CERT_ImportCerts(CERTCertDBHandle *certdb, SECCertUsage usage,
  1105.          unsigned int ncerts, SECItem **derCerts,
  1106.          CERTCertificate ***retCerts, PRBool keepCerts,
  1107.          PRBool caOnly, char *nickname);
  1108.  
  1109. SECStatus
  1110. CERT_SaveImportedCert(CERTCertificate *cert, SECCertUsage usage,
  1111.               PRBool caOnly, char *nickname);
  1112.  
  1113. char *
  1114. CERT_MakeCANickname(CERTCertificate *cert);
  1115.  
  1116. PRBool
  1117. CERT_IsCACert(CERTCertificate *cert, unsigned int *rettype);
  1118.  
  1119. PRBool
  1120. CERT_IsCADERCert(SECItem *derCert, unsigned int *rettype);
  1121.  
  1122. PRBool
  1123. CERT_IsRootDERCert(SECItem *derCert);
  1124.  
  1125. SECStatus
  1126. CERT_SaveSMimeProfile(CERTCertificate *cert, SECItem *emailProfile,
  1127.               SECItem *profileTime);
  1128.  
  1129. /*
  1130.  * find the smime symmetric capabilities profile for a given cert
  1131.  */
  1132. SECItem *
  1133. CERT_FindSMimeProfile(CERTCertificate *cert);
  1134.  
  1135. SECStatus
  1136. CERT_AddNewCerts(CERTCertDBHandle *handle);
  1137.  
  1138. CERTPackageType
  1139. CERT_CertPackageType(SECItem *package, SECItem *certitem);
  1140.  
  1141. CERTCertificatePolicies *
  1142. CERT_DecodeCertificatePoliciesExtension(SECItem *extnValue);
  1143.  
  1144. void
  1145. CERT_DestroyCertificatePoliciesExtension(CERTCertificatePolicies *policies);
  1146.  
  1147. CERTUserNotice *
  1148. CERT_DecodeUserNotice(SECItem *noticeItem);
  1149.  
  1150. extern CERTGeneralName *
  1151. CERT_DecodeAltNameExtension(PRArenaPool *arena, SECItem *EncodedAltName);
  1152.  
  1153. extern CERTNameConstraints *
  1154. CERT_DecodeNameConstraintsExtension(PRArenaPool *arena, 
  1155.                                     SECItem *encodedConstraints);
  1156.  
  1157. /* returns addr of a NULL termainated array of pointers to CERTAuthInfoAccess */
  1158. extern CERTAuthInfoAccess **
  1159. CERT_DecodeAuthInfoAccessExtension(PRArenaPool *arena,
  1160.                    SECItem     *encodedExtension);
  1161.  
  1162. extern CERTPrivKeyUsagePeriod *
  1163. CERT_DecodePrivKeyUsagePeriodExtension(PLArenaPool *arena, SECItem *extnValue);
  1164.  
  1165. extern CERTGeneralName *
  1166. CERT_GetNextGeneralName(CERTGeneralName *current);
  1167.  
  1168. extern CERTGeneralName *
  1169. CERT_GetPrevGeneralName(CERTGeneralName *current);
  1170.  
  1171. CERTNameConstraint *
  1172. CERT_GetNextNameConstraint(CERTNameConstraint *current);
  1173.  
  1174. CERTNameConstraint *
  1175. CERT_GetPrevNameConstraint(CERTNameConstraint *current);
  1176.  
  1177. void
  1178. CERT_DestroyUserNotice(CERTUserNotice *userNotice);
  1179.  
  1180. typedef char * (* CERTPolicyStringCallback)(char *org,
  1181.                            unsigned long noticeNumber,
  1182.                            void *arg);
  1183. void
  1184. CERT_SetCAPolicyStringCallback(CERTPolicyStringCallback cb, void *cbarg);
  1185.  
  1186. char *
  1187. CERT_GetCertCommentString(CERTCertificate *cert);
  1188.  
  1189. PRBool
  1190. CERT_GovtApprovedBitSet(CERTCertificate *cert);
  1191.  
  1192. SECStatus
  1193. CERT_AddPermNickname(CERTCertificate *cert, char *nickname);
  1194.  
  1195. /*
  1196.  * Given a cert, find the cert with the same subject name that
  1197.  * has the given key usage.  If the given cert has the correct keyUsage, then
  1198.  * return it, otherwise search the list in order.
  1199.  */
  1200. CERTCertificate *
  1201. CERT_FindCertByUsage(CERTCertificate *basecert, unsigned int requiredKeyUsage);
  1202.  
  1203.  
  1204. CERTCertList *
  1205. CERT_MatchUserCert(CERTCertDBHandle *handle,
  1206.            SECCertUsage usage,
  1207.            int nCANames, char **caNames,
  1208.            void *proto_win);
  1209.  
  1210. CERTCertList *
  1211. CERT_NewCertList(void);
  1212.  
  1213. void
  1214. CERT_DestroyCertList(CERTCertList *certs);
  1215.  
  1216. /* remove the node and free the cert */
  1217. void
  1218. CERT_RemoveCertListNode(CERTCertListNode *node);
  1219.  
  1220. SECStatus
  1221. CERT_AddCertToListTail(CERTCertList *certs, CERTCertificate *cert);
  1222.  
  1223. SECStatus
  1224. CERT_AddCertToListHead(CERTCertList *certs, CERTCertificate *cert);
  1225.  
  1226. SECStatus
  1227. CERT_AddCertToListTailWithData(CERTCertList *certs, CERTCertificate *cert,
  1228.                              void *appData);
  1229.  
  1230. SECStatus
  1231. CERT_AddCertToListHeadWithData(CERTCertList *certs, CERTCertificate *cert,
  1232.                              void *appData);
  1233.  
  1234. typedef PRBool (* CERTSortCallback)(CERTCertificate *certa,
  1235.                     CERTCertificate *certb,
  1236.                     void *arg);
  1237. SECStatus
  1238. CERT_AddCertToListSorted(CERTCertList *certs, CERTCertificate *cert,
  1239.              CERTSortCallback f, void *arg);
  1240.  
  1241. /* callback for CERT_AddCertToListSorted that sorts based on validity
  1242.  * period and a given time.
  1243.  */
  1244. PRBool
  1245. CERT_SortCBValidity(CERTCertificate *certa,
  1246.             CERTCertificate *certb,
  1247.             void *arg);
  1248.  
  1249. SECStatus
  1250. CERT_CheckForEvilCert(CERTCertificate *cert);
  1251.  
  1252. CERTGeneralName *
  1253. CERT_GetCertificateNames(CERTCertificate *cert, PRArenaPool *arena);
  1254.  
  1255.  
  1256. SECStatus 
  1257. CERT_EncodeSubjectKeyID(PRArenaPool *arena, char *value, int len, SECItem *encodedValue);
  1258.  
  1259. char *
  1260. CERT_GetNickName(CERTCertificate   *cert, CERTCertDBHandle *handle, PRArenaPool *nicknameArena);
  1261.  
  1262. /*
  1263.  * Creates or adds to a list of all certs with a give subject name, sorted by
  1264.  * validity time, newest first.  Invalid certs are considered older than
  1265.  * valid certs. If validOnly is set, do not include invalid certs on list.
  1266.  */
  1267. CERTCertList *
  1268. CERT_CreateSubjectCertList(CERTCertList *certList, CERTCertDBHandle *handle,
  1269.                SECItem *name, int64 sorttime, PRBool validOnly);
  1270.  
  1271. /*
  1272.  * Creates or adds to a list of all certs with a give nickname, sorted by
  1273.  * validity time, newest first.  Invalid certs are considered older than valid
  1274.  * certs. If validOnly is set, do not include invalid certs on list.
  1275.  */
  1276. CERTCertList *
  1277. CERT_CreateNicknameCertList(CERTCertList *certList, CERTCertDBHandle *handle,
  1278.                 char *nickname, int64 sorttime, PRBool validOnly);
  1279.  
  1280. /*
  1281.  * Creates or adds to a list of all certs with a give email addr, sorted by
  1282.  * validity time, newest first.  Invalid certs are considered older than valid
  1283.  * certs. If validOnly is set, do not include invalid certs on list.
  1284.  */
  1285. CERTCertList *
  1286. CERT_CreateEmailAddrCertList(CERTCertList *certList, CERTCertDBHandle *handle,
  1287.                  char *emailAddr, int64 sorttime, PRBool validOnly);
  1288.  
  1289. /*
  1290.  * remove certs from a list that don't have keyUsage and certType
  1291.  * that match the given usage.
  1292.  */
  1293. SECStatus
  1294. CERT_FilterCertListByUsage(CERTCertList *certList, SECCertUsage usage,
  1295.                PRBool ca);
  1296.  
  1297. /*
  1298.  * check the key usage of a cert against a set of required values
  1299.  */
  1300. SECStatus
  1301. CERT_CheckKeyUsage(CERTCertificate *cert, unsigned int requiredUsage);
  1302.  
  1303. /*
  1304.  * return required key usage and cert type based on cert usage
  1305.  */
  1306. SECStatus
  1307. CERT_KeyUsageAndTypeForCertUsage(SECCertUsage usage,
  1308.                  PRBool ca,
  1309.                  unsigned int *retKeyUsage,
  1310.                  unsigned int *retCertType);
  1311. /*
  1312.  * return required trust flags for various cert usages for CAs
  1313.  */
  1314. SECStatus
  1315. CERT_TrustFlagsForCACertUsage(SECCertUsage usage,
  1316.                   unsigned int *retFlags,
  1317.                   SECTrustType *retTrustType);
  1318.  
  1319. /*
  1320.  * Find all user certificates that match the given criteria.
  1321.  * 
  1322.  *    "handle" - database to search
  1323.  *    "usage" - certificate usage to match
  1324.  *    "oneCertPerName" - if set then only return the "best" cert per
  1325.  *            name
  1326.  *    "validOnly" - only return certs that are curently valid
  1327.  *    "proto_win" - window handle passed to pkcs11
  1328.  */
  1329. CERTCertList *
  1330. CERT_FindUserCertsByUsage(CERTCertDBHandle *handle,
  1331.               SECCertUsage usage,
  1332.               PRBool oneCertPerName,
  1333.               PRBool validOnly,
  1334.               void *proto_win);
  1335.  
  1336. /*
  1337.  * Find a user certificate that matchs the given criteria.
  1338.  * 
  1339.  *    "handle" - database to search
  1340.  *    "nickname" - nickname to match
  1341.  *    "usage" - certificate usage to match
  1342.  *    "validOnly" - only return certs that are curently valid
  1343.  *    "proto_win" - window handle passed to pkcs11
  1344.  */
  1345. CERTCertificate *
  1346. CERT_FindUserCertByUsage(CERTCertDBHandle *handle,
  1347.              char *nickname,
  1348.              SECCertUsage usage,
  1349.              PRBool validOnly,
  1350.              void *proto_win);
  1351.  
  1352. /*
  1353.  * Filter a list of certificates, removing those certs that do not have
  1354.  * one of the named CA certs somewhere in their cert chain.
  1355.  *
  1356.  *    "certList" - the list of certificates to filter
  1357.  *    "nCANames" - number of CA names
  1358.  *    "caNames" - array of CA names in string(rfc 1485) form
  1359.  *    "usage" - what use the certs are for, this is used when
  1360.  *        selecting CA certs
  1361.  */
  1362. SECStatus
  1363. CERT_FilterCertListByCANames(CERTCertList *certList, int nCANames,
  1364.                  char **caNames, SECCertUsage usage);
  1365.  
  1366. /*
  1367.  * Filter a list of certificates, removing those certs that aren't user certs
  1368.  */
  1369. SECStatus
  1370. CERT_FilterCertListForUserCerts(CERTCertList *certList);
  1371.  
  1372. /*
  1373.  * Collect the nicknames from all certs in a CertList.  If the cert is not
  1374.  * valid, append a string to that nickname.
  1375.  *
  1376.  * "certList" - the list of certificates
  1377.  * "expiredString" - the string to append to the nickname of any expired cert
  1378.  * "notYetGoodString" - the string to append to the nickname of any cert
  1379.  *        that is not yet valid
  1380.  */
  1381. CERTCertNicknames *
  1382. CERT_NicknameStringsFromCertList(CERTCertList *certList, char *expiredString,
  1383.                  char *notYetGoodString);
  1384.  
  1385. /*
  1386.  * Extract the nickname from a nickmake string that may have either
  1387.  * expiredString or notYetGoodString appended.
  1388.  *
  1389.  * Args:
  1390.  *    "namestring" - the string containing the nickname, and possibly
  1391.  *        one of the validity label strings
  1392.  *    "expiredString" - the expired validity label string
  1393.  *    "notYetGoodString" - the not yet good validity label string
  1394.  *
  1395.  * Returns the raw nickname
  1396.  */
  1397. char *
  1398. CERT_ExtractNicknameString(char *namestring, char *expiredString,
  1399.                char *notYetGoodString);
  1400.  
  1401. /*
  1402.  * Given a certificate, return a string containing the nickname, and possibly
  1403.  * one of the validity strings, based on the current validity state of the
  1404.  * certificate.
  1405.  *
  1406.  * "arena" - arena to allocate returned string from.  If NULL, then heap
  1407.  *    is used.
  1408.  * "cert" - the cert to get nickname from
  1409.  * "expiredString" - the string to append to the nickname if the cert is
  1410.  *        expired.
  1411.  * "notYetGoodString" - the string to append to the nickname if the cert is
  1412.  *        not yet good.
  1413.  */
  1414. char *
  1415. CERT_GetCertNicknameWithValidity(PRArenaPool *arena, CERTCertificate *cert,
  1416.                  char *expiredString, char *notYetGoodString);
  1417.  
  1418. /*
  1419.  * Return the string representation of a DER encoded distinguished name
  1420.  * "dername" - The DER encoded name to convert
  1421.  */
  1422. char *
  1423. CERT_DerNameToAscii(SECItem *dername);
  1424.  
  1425. /*
  1426.  * Supported usage values and types:
  1427.  *    certUsageSSLClient
  1428.  *    certUsageSSLServer
  1429.  *    certUsageSSLServerWithStepUp
  1430.  *    certUsageEmailSigner
  1431.  *    certUsageEmailRecipient
  1432.  *    certUsageObjectSigner
  1433.  */
  1434.  
  1435. CERTCertificate *
  1436. CERT_FindMatchingCert(CERTCertDBHandle *handle, SECItem *derName,
  1437.               CERTCertOwner owner, SECCertUsage usage,
  1438.               PRBool preferTrusted, int64 validTime, PRBool validOnly);
  1439.  
  1440. /*
  1441.  * Acquire the global lock on the cert database.
  1442.  * This lock is currently used for the following operations:
  1443.  *    adding or deleting a cert to either the temp or perm databases
  1444.  *    converting a temp to perm or perm to temp
  1445.  *    changing(maybe just adding?) the trust of a cert
  1446.  *    adjusting the reference count of a cert
  1447.  */
  1448. void
  1449. CERT_LockDB(CERTCertDBHandle *handle);
  1450.  
  1451. /*
  1452.  * Free the global cert database lock.
  1453.  */
  1454. void
  1455. CERT_UnlockDB(CERTCertDBHandle *handle);
  1456.  
  1457. /*
  1458.  * Get the certificate status checking configuratino data for
  1459.  * the certificate database
  1460.  */
  1461. CERTStatusConfig *
  1462. CERT_GetStatusConfig(CERTCertDBHandle *handle);
  1463.  
  1464. /*
  1465.  * Set the certificate status checking information for the
  1466.  * database.  The input structure becomes part of the certificate
  1467.  * database and will be freed by calling the 'Destroy' function in
  1468.  * the configuration object.
  1469.  */
  1470. void
  1471. CERT_SetStatusConfig(CERTCertDBHandle *handle, CERTStatusConfig *config);
  1472.  
  1473.  
  1474.  
  1475. /*
  1476.  * Acquire the cert reference count lock
  1477.  * There is currently one global lock for all certs, but I'm putting a cert
  1478.  * arg here so that it will be easy to make it per-cert in the future if
  1479.  * that turns out to be necessary.
  1480.  */
  1481. void
  1482. CERT_LockCertRefCount(CERTCertificate *cert);
  1483.  
  1484. /*
  1485.  * Free the cert reference count lock
  1486.  */
  1487. void
  1488. CERT_UnlockCertRefCount(CERTCertificate *cert);
  1489.  
  1490. /*
  1491.  * Acquire the cert trust lock
  1492.  * There is currently one global lock for all certs, but I'm putting a cert
  1493.  * arg here so that it will be easy to make it per-cert in the future if
  1494.  * that turns out to be necessary.
  1495.  */
  1496. void
  1497. CERT_LockCertTrust(CERTCertificate *cert);
  1498.  
  1499. /*
  1500.  * Free the cert trust lock
  1501.  */
  1502. void
  1503. CERT_UnlockCertTrust(CERTCertificate *cert);
  1504.  
  1505. /*
  1506.  * Digest the cert's subject public key using the specified algorithm.
  1507.  * The necessary storage for the digest data is allocated.  If "fill" is
  1508.  * non-null, the data is put there, otherwise a SECItem is allocated.
  1509.  * Allocation from "arena" if it is non-null, heap otherwise.  Any problem
  1510.  * results in a NULL being returned (and an appropriate error set).
  1511.  */ 
  1512. extern SECItem *
  1513. CERT_SPKDigestValueForCert(PRArenaPool *arena, CERTCertificate *cert,
  1514.                SECOidTag digestAlg, SECItem *fill);
  1515.  
  1516. /*
  1517.  * fill in nsCertType field of the cert based on the cert extension
  1518.  */
  1519. extern SECStatus cert_GetCertType(CERTCertificate *cert);
  1520.  
  1521.  
  1522. SECStatus CERT_CheckCRL(CERTCertificate* cert, CERTCertificate* issuer,
  1523.                         SECItem* dp, int64 t, void* wincx);
  1524.  
  1525.  
  1526. SEC_END_PROTOS
  1527.  
  1528. #endif /* _CERT_H_ */
  1529.